home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / snippet.exe / RTLFTRUL.TXT < prev    next >
Encoding:
Text File  |  1992-05-31  |  4.9 KB  |  141 lines
  1. Organization: KFW Corporation, Newbury Park, CA
  2. Message-ID: <1990Jul16.195111.5976@kfw.COM>
  3. Newsgroups: comp.lang.c
  4.  
  5. I've received several mail messages since offering to explain the 
  6. right-left rule via e-mail, so I've decided to post.  For those of
  7. you who already know this or don't care, quit now (this is a little
  8. long).
  9.  
  10. The "right-left" rule is a completely regular rule for deciphering C
  11. declarations.  It can also be useful in creating them.
  12.  
  13. First, symbols.  Read
  14.  
  15.      *          as "pointer to"
  16.      []         as "array of"
  17.      ()         as "function returning"
  18.  
  19. as you encounter them in the declaration.
  20.  
  21. STEP 1
  22. ------
  23. Find the identifier.  This is your starting point.  Then say to yourself,
  24. "identifier is".  You've started your declaration.
  25.  
  26. STEP 2
  27. ------
  28. Look at the symbols on the right of the identifier.  If, say, you find "()"
  29. there, then you know that this is the declaration for a function.  So you
  30. would then have "identifier is function returning".  Or if you found a 
  31. "[]" there, you would say "identifier is array of".  Continue right until
  32. you run out of symbols *OR* hit a *right* parenthesis ")".  (If you hit a 
  33. left parenthesis, that's the beginning of a () symbol, even if there
  34. is stuff in between the parentheses.  More on that below.)
  35.  
  36. STEP 3
  37. ------
  38. Look at the symbols to the left of the identifier.  If it is not one of our
  39. symbols above (say, something like "int"), just say it.  Otherwise, translate
  40. it into English using that table above.  Keep going left until you run out of
  41. symbols *OR* hit a *left* parenthesis "(".  
  42.  
  43. Now repeat steps 2 and 3 until you've formed your declaration.  Here are some
  44. examples:
  45.  
  46.      int *p[];
  47.  
  48. 1) Find identifier.          int *p[];
  49.                                   ^
  50.    "p is"
  51.  
  52. 2) Move right until out of symbols or left parenthesis hit.
  53.                              int *p[];
  54.                                    ^^
  55.    "p is array of"
  56.  
  57. 3) Can't move right anymore (out of symbols), so move left and find:
  58.                              int *p[];
  59.                                  ^
  60.    "p is array of pointer to"
  61.  
  62. 4) Keep going left and find:
  63.                              int *p[];
  64.                              ^^^
  65.    "p is array of pointer to int".
  66.  
  67. Another example:
  68.  
  69.    int *(*func())();
  70.  
  71. 1) Find the identifier.      int *(*func())();
  72.                                     ^^^^
  73.    "func is"
  74.  
  75. 2) Move right.               int *(*func())();
  76.                                         ^^
  77.    "func is function returning"
  78.  
  79. 3) Can't move right anymore because of the right parenthesis, so move left.
  80.                              int *(*func())();
  81.                                    ^
  82.    "func is function returning pointer to"
  83.  
  84. 4) Can't move left anymore because of the left parenthesis, so keep going
  85.    right.                    int *(*func())();
  86.                                            ^^
  87.    "func is function returning pointer to function returning"
  88.  
  89. 5) Can't move right anymore because we're out of symbols, so go left.
  90.                              int *(*func())();
  91.                                  ^
  92.    "func is function returning pointer to function returning pointer to"
  93.  
  94. 6) And finally, keep going left, because there's nothing left on the right.
  95.                              int *(*func())();
  96.                              ^^^
  97.    "func is function returning pointer to function returning pointer to int".
  98.  
  99. As you can see, this rule can be quite useful.  You can also use it to
  100. sanity check yourself while you are creating declarations, and to give
  101. you a hint about where the put the next symbol and whether parentheses
  102. are required.
  103.  
  104. Some declarations look much more complicated than they are due to array
  105. sizes and argument lists in prototype form.  If you see "[3]", that's
  106. read as "array (size 3) of...".  If you see "(char *,int)" that's read
  107. as "function expecting (char *,int) and returning...".  Here's a fun
  108. one:
  109.  
  110.                  int (*(*fun_one)(char *,double))[9][20];
  111.  
  112. I won't go through each of the steps to decipher this one.  It's:
  113.  
  114.      "fun_one is pointer to function expecting (char *,double) and 
  115.       returning pointer to array (size 9) of array (size 20) of int."
  116.  
  117. As you can see, it's not as complicated if you get rid of the array sizes
  118. and argument lists:
  119.  
  120.      int (*(*fun_one)())[][];
  121.  
  122. You can decipher it that way, and then put in the array sizes and argument
  123. lists later.
  124.  
  125. Some final words:
  126.  
  127. It is quite possible to make illegal declarations using this rule,
  128. so some knowledge of what's legal in C is necessary.  For instance,
  129. if the above had been:
  130.  
  131.      int *((*fun_one)())[][];
  132.  
  133. it would have been "fun_one is pointer to function returning array of array of
  134.                                           ^^^^^^^^^^^^^^^^^^^^^^^^
  135. pointer to int".  Since a function cannot return an array, but only a 
  136. pointer to an array, that declaration is illegal.
  137.  
  138. Will
  139. will@kfw.com
  140. uunet!charyb!will 
  141.